home *** CD-ROM | disk | FTP | other *** search
/ PC Home MegaDisk 20 / PC Home MegaDisk 1994-05 Issue 20.img / HIGHCS.EXE / GRABIMG.C < prev    next >
Encoding:
C/C++ Source or Header  |  1994-03-26  |  10.1 KB  |  472 lines
  1. /***************************************************************************
  2.  *                                                                         *
  3.  *   File Name:      GRABIMG.C                                             *
  4.  *   Description:    Build Image (IM) file from on-screen image.           *
  5.  *   Notes:          This program displays a PCX picture and allows you to *
  6.  *                   click inside a boundary of colour 255.  It then grabs *
  7.  *                   everthing within that boundary and saves it as an     *
  8.  *                   image.  You can keep clicking if you want a "bank" of *
  9.  *                   two or more images.                                   *
  10.  *                                                                         *
  11.  *   Special Note:   The mouse pointer in this program is an excellent     *
  12.  *                   example of how you can use the image system as a      *
  13.  *                   sprite system.  The "proper" version of this program  *
  14.  *                   uses the full-blown sprite system to display the      *
  15.  *                   mouse, so I rewrote it to show you how you can use    *
  16.  *                   just the image system described this month to do some *
  17.  *                   quite nice stuff.                                     *
  18.  *                                                                         *
  19.  *                   As of this month, there'll be three files included on *
  20.  *                   the disk:-                                            *
  21.  *                   HIGHC.OBJ   All the functions we've developed so far  *
  22.  *                   HIGHC.C     The source to them                        *
  23.  *                   HIGHC.H     A header file for structures and soforth  *
  24.  *                                                                         *
  25.  *                   You MUST tell your compiler/linker to include         *
  26.  *                   HIGHC.OBJ at link time, otherwise it won't be able to *
  27.  *                   find all the "basic" functions like g_SetVGA.         *
  28.  *                                                                         *
  29.  ***************************************************************************/
  30.  
  31. #include "highc.h"      // From now on, include this in every program
  32. #include "alloc.h"
  33. #include "stdlib.h"
  34. #include "stdio.h"
  35. #include "string.h"
  36.  
  37. #define NO_FILE   -1
  38. #define NOT_KNOWN -2
  39. #define PCX        1         // Just to make it read a bit nicer
  40.  
  41. typedef struct {
  42.         char far *ptr;
  43.         int  h, w;
  44.         int  t, l;
  45.         char far *sptr;
  46.         } IMAGE_DEFN;
  47.  
  48. IMAGE_DEFN img[30];
  49.  
  50. char *gen_IM(char *string);
  51.  
  52. main(int argc, char *argv[])
  53. {
  54.  
  55. char *IM_file;
  56. char far *t;
  57. signed char x;
  58. unsigned char w, h, contin;
  59. char signature[25];
  60. FILE *fp;
  61.  
  62.  
  63. if (argc != 3)
  64.    {
  65.    printf("Usage:  GRABIMG {PCX_Picture_file} {Image_file}\n");
  66.    exit(0);
  67.    }
  68.  
  69. sbptr   = farcalloc(64000, 1);      // Allocate the screen buffer
  70. palette = farcalloc(768, 1);        // Allocate the palette space
  71.  
  72. g_SetVGA();
  73. x=g_LoadScreen(argv[1]);
  74.  
  75. if (x != PCX)
  76.    {
  77.    g_SetTxt();
  78.    printf("Error!  Non-existent or non-PCX file %s\n", argv[1]);
  79.    exit(0);
  80.    }
  81.  
  82. IM_file = gen_IM(argv[2]);  // If the user hasn't entered the ".IM"
  83.                             // extension, add it.
  84.  
  85. fp = fopen(IM_file, "rb");
  86.  
  87. if (fp == NULL)
  88.    {
  89.    fp = fopen(IM_file, "wb");
  90.    fwrite("Image File", 1, 10, fp);
  91.    }
  92. else
  93.    {
  94.    fseek(fp, 0L, SEEK_SET);
  95.    fread(signature, 1, 10, fp);
  96.    if (strncmp(signature, "Image File", 10) != 0)
  97.       {
  98.       g_SetTxt();
  99.       printf("Error!  File %s is not a valid Image file\n", IM_file);
  100.       exit(0);
  101.       }
  102.    fclose(fp);
  103.    fp = fopen(IM_file, "ab");
  104.    }
  105.  
  106. load_img("grabimg.im", 0);  // The image bank that contains my mouse pointer
  107. pasteimg(0, 160, 100);      // Bung it out on screen
  108.  
  109. contin = 1;
  110.  
  111. while (contin)
  112.       {
  113.       MCheck();
  114.       if (m.lmr)
  115.          add_im(fp);
  116.       if (m.rmr)
  117.          contin = 0;
  118.       update_mouse();    // Remove the pointer from screen & redraw it
  119.       g_SwapScr();
  120.       }
  121.  
  122. fclose(fp);
  123.  
  124. g_SetTxt();
  125.  
  126. return(OK);
  127. }
  128.  
  129.  
  130. char *gen_PCX(char *filnam)
  131. {
  132.  
  133. static char pcxnam[100];
  134. char *s1, ss;
  135.  
  136.    if ( (s1 = strstr(strupr(filnam), ".PCC")) == NULL)
  137.       {
  138.       if ( (s1 = strstr(strupr(filnam), ".PCX")) == NULL)
  139.          {
  140.          strcpy(pcxnam, filnam);
  141.          strcat(pcxnam, ".PCX");
  142.          }
  143.       else
  144.          {
  145.          ss = s1 - filnam;
  146.          strncpy(pcxnam, filnam, ss);
  147.          }
  148.       }
  149.    else
  150.       {
  151.       ss = s1 - filnam;
  152.       strncpy(pcxnam, filnam, ss);
  153.       }
  154.  
  155. s1 = pcxnam;
  156.  
  157. return(s1);
  158.  
  159. }
  160.  
  161.  
  162. char *gen_IM(char *filnam)
  163. {
  164.  
  165. static char imnam[100];
  166. char *s1, ss;
  167.  
  168.    if ( (s1 = strstr(strupr(imnam), ".IM")) == NULL)
  169.       {
  170.       strcpy(imnam, filnam);
  171.       strcat(imnam, ".IM");
  172.       }
  173.    else
  174.       {
  175.       ss = s1 - imnam;
  176.       strncpy(imnam, filnam, ss);
  177.       }
  178.  
  179.  
  180. return(imnam);
  181.  
  182. }
  183.  
  184. add_im(FILE *fp)
  185. {
  186.  
  187. int x, y;
  188. unsigned char ctr;
  189. int  lc, tc, bc, rc;
  190. char *sptr;
  191.  
  192. removeimg(0);    // Take the pointer off screen - you don't want to save it
  193.                  // as part of this image.
  194.  
  195. /* OK, first things first.  Go up until you find a colour 255 pixel.  Go back
  196.    down one.  Then travel left until you hit a colour 255 pixel.  Go one back
  197.    to the right.  And there you are, at the top left corner of your box!   */
  198.  
  199. ctr = 0; tc = 0; lc = 0;
  200. while (ctr++ < 170)
  201.       {
  202.       sptr = g_FPtr(sbptr, ((m.my - ctr) * 320) + m.mx);
  203.       if (*sptr == 255)
  204.          {
  205.          tc = (m.my - ctr) + 1;
  206.          ctr = 170;
  207.          }
  208.       }
  209.  
  210. if (tc == 0)
  211.    {
  212.    tc = m.my;
  213.    lc = m.mx;
  214.    }
  215. else
  216.    {
  217.    ctr = 0;
  218.    while (ctr++ < 170)
  219.          {
  220.          sptr = g_FPtr(sbptr, ((m.my * 320) + m.mx) - ctr);
  221.          if (*sptr == 255)
  222.             {
  223.             lc = (m.mx - ctr) + 1;
  224.             ctr = 170;
  225.             }
  226.          }
  227.    }
  228.  
  229. if (lc == 0)
  230.    lc = m.mx;
  231.  
  232.  
  233. /* Now find the bottom-right of the box...     */
  234.  
  235. ctr = 0; bc = 0; rc = 0;
  236. while (ctr++ < 170)
  237.       {
  238.       sptr = g_FPtr(sbptr, ((m.my + ctr) * 320) + m.mx);
  239.       if (*sptr == 255)
  240.          {
  241.          bc = (m.my + ctr) - 1;
  242.          ctr = 170;
  243.          }
  244.       }
  245.  
  246. if (bc == 0)
  247.    {
  248.    bc = m.my+10;
  249.    rc = m.mx+10;
  250.    }
  251. else
  252.    {
  253.    ctr = 0;
  254.    while (ctr++ < 170)
  255.          {
  256.          sptr = g_FPtr(sbptr, ((m.my * 320) + m.mx) + ctr);
  257.          if (*sptr == 255)
  258.             {
  259.             rc = (m.mx + ctr) - 1;
  260.             ctr = 170;
  261.             }
  262.          }
  263.    }
  264.  
  265. if (rc == 0)
  266.    rc = m.mx+10;
  267.  
  268. fputc(255, fp);                // Start of new image marker
  269. fputc( (char)rc-lc, fp);       // Width (0-255)
  270. fputc( (char)(bc-tc)+1, fp);   // Height (0-200)
  271.  
  272. for (x=0; x <= bc-tc; x++)
  273.     {
  274.     sptr = g_FPtr(sbptr, ((tc + x) * 320) + (lc));
  275.     for (y=0; y < rc-lc; y++)
  276.         fputc(*sptr++, fp);
  277.     }
  278.  
  279. return(1);
  280. }
  281.  
  282.  
  283. update_mouse()
  284. {
  285. removeimg(0);
  286. pasteimg(0, m.mx, m.my);
  287. return(0);
  288. }
  289.  
  290. pasteimg(char imgnum, int l, int t)
  291.  
  292. {
  293.  
  294. unsigned int j, k, h, w, m, n;
  295. char far *sp1;
  296. char far *sp2;
  297.  
  298. if (imgnum < 0 || imgnum > 30)     // We're only allowing 30 images at one time
  299.    return(-1);                     // (could easily be increased)
  300.  
  301. if (l < 0 || t < 0 || l > 319 || t > 199)
  302.    return(-2);                     // Don't paste an image off the edge of
  303.                                    // the screen.
  304.  
  305. if ( (sp2 = img[imgnum].ptr) == NULL)
  306.    return(-3);                     // The requested image has no image data
  307.  
  308. w = img[imgnum].w;
  309. h = img[imgnum].h;
  310.  
  311. if (img[imgnum].sptr != NULL)      // If, for some reason, the background is
  312.    farfree(img[imgnum].sptr);      // already saved, throw it away
  313.  
  314. if ( (img[imgnum].sptr = farcalloc(w*h, 1)) == NULL)
  315.    return(-4);                     // Not enough memory to save background
  316.  
  317. save_IMG_back(imgnum, l, t);
  318.  
  319. m = 0;
  320.  
  321. for (j = 0; j < h; j++)
  322.     {
  323.     if (j+t < 200)
  324.        {
  325.        sp1 = g_FPtr(sbptr, (t * 320) + (j * 320) + l);
  326.        n = 0;
  327.        for (k = 0; k < w; k++)
  328.            {
  329.            if (sp2[m] != 0 && k+l < 320)
  330.               sp1[n] = sp2[m];
  331.            n++; m++;
  332.            }
  333.        }
  334.     }
  335.  
  336.     img[imgnum].t = t;
  337.     img[imgnum].l = l;
  338.  
  339.     return(OK);
  340.  
  341. }
  342.  
  343.  
  344. save_IMG_back(imgnum, l, t)
  345.  
  346. int l, t;
  347. char imgnum;
  348.  
  349. {
  350.  
  351. unsigned int j, k, w, h, n, m;
  352. char far *sp1;
  353. char far *sp2;
  354.  
  355. sp2 = img[imgnum].sptr;
  356. w =   img[imgnum].w;
  357. h =   img[imgnum].h;
  358. m =   0;
  359.  
  360. for (j = 0; j < h; j++)
  361.     {
  362.     sp1 = g_FPtr(sbptr, (t * 320) + (j * 320) + l);
  363.     n = 0;
  364.     for (k = 0; k < w; k++)
  365.         sp2[m++] = sp1[n++];
  366.     }
  367.  
  368. return(OK);
  369.  
  370. }
  371.  
  372.  
  373. removeimg(imgnum)
  374. char imgnum;
  375.  
  376. {
  377.  
  378. unsigned int j, k, n, t, l, w, h, m;
  379. char far *sp1;
  380. char far *sp2;
  381.  
  382. if (img[imgnum].sptr == NULL)
  383.    return(-1);               // Image is not on screen
  384.  
  385. sp2 = img[imgnum].sptr;
  386. t   = img[imgnum].t;
  387. l   = img[imgnum].l;
  388. w   = img[imgnum].w;
  389. h   = img[imgnum].h;
  390.  
  391. m   = 0;
  392.  
  393.  
  394. for (j = 0; j < h; j++)
  395.     {
  396.     if (j+t < 200)
  397.        {
  398.        sp1 = g_FPtr(sbptr, (t * 320) + (j * 320) + l);
  399.        n = 0;
  400.        for (k = 0; k < w; k++)
  401.            {
  402.            if (k+l < 320)
  403.               sp1[n] = sp2[m];
  404.            n++; m++;
  405.            }
  406.        }
  407.     }
  408.  
  409.     farfree(img[imgnum].sptr);
  410.     img[imgnum].sptr = 0;
  411.  
  412. return(OK);
  413.  
  414. }
  415.  
  416.  
  417. load_img(char *filnam, char append)
  418. {
  419.  
  420. int j, k, w, h;
  421. FILE *fp;
  422. char far *t;
  423. char sig[21];
  424.  
  425. if ( (fp = fopen(filnam, "rb")) == NULL)
  426.    return(NO_FILE);
  427.  
  428. if (append)
  429.    {
  430.    for (j=0; j<50; j++)
  431.        if (img[j].ptr == NULL)
  432.           break;
  433.    }
  434. else
  435.    j=0;
  436.  
  437. fread(sig, 1, 10, fp);
  438. sig[10] = 0;
  439.  
  440. if ( strcmp("Image File", sig) != NULL)
  441.    return(NOT_KNOWN);
  442.  
  443. while (!feof(fp) && j < 50)
  444.    {
  445.    if (fgetc(fp) != 255)
  446.       break;
  447.  
  448.    w = (int)fgetc(fp);
  449.    h = (int)fgetc(fp);
  450.  
  451.    t = farcalloc(w*h, 1);
  452.  
  453.    fread(t, 1, w*h, fp);
  454.  
  455.    img[j].ptr = t;
  456.    img[j].w   = w;
  457.    img[j++].h = h;
  458.    }
  459.  
  460.   while (j++ < 50)
  461.      {
  462.      img[j].ptr = NULL;
  463.      img[j].w   = 0;
  464.      img[j].h   = 0;
  465.      }
  466.  
  467.  
  468.  
  469. return(OK);
  470.  
  471. }
  472.